home *** CD-ROM | disk | FTP | other *** search
/ Collection of Internet / Collection of Internet.iso / msdos / lynx / source / www / library / implemen / htfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-25  |  28.7 KB  |  1,111 lines
  1. /*            File Access                HTFile.c
  2. **            ===========
  3. **
  4. **    This is unix-specific code in general, with some VMS bits.
  5. **    These are routines for file access used by browsers.
  6. **
  7. ** History:
  8. **       Feb 91    Written Tim Berners-Lee CERN/CN
  9. **       Apr 91    vms-vms access included using DECnet syntax
  10. **    26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  11. **            Fixed access bug for relative names on VMS.
  12. **       Sep 93 (MD)  Access to VMS files allows sharing.
  13. **    15 Nov 93 (MD)    Moved HTVMSname to HTVMSUTILS.C
  14. **
  15. ** Bugs:
  16. **    FTP: Cannot access VMS files from a unix machine.
  17. **      How can we know that the
  18. **    target machine runs VMS?
  19. */
  20.  
  21. #include"capalloc.h"
  22. #include "HTFile.h"        /* Implemented here */
  23. #include"capstdio.h"
  24.  
  25.  
  26. #define INFINITY 512        /* file name length @@ FIXME */
  27. #define MULTI_SUFFIX ".multi"   /* Extension for scanning formats */
  28.  
  29. #include "HTUtils.h"
  30.  
  31. #ifdef VMS
  32. #include "HTVMSUtils.h"
  33. #endif /* VMS */
  34.  
  35. #include "HTParse.h"
  36. #include "tcp.h"
  37. #include "HTTCP.h"
  38. #ifndef DECNET
  39. #include "HTFTP.h"
  40. #endif
  41. #include "HTAnchor.h"
  42. #include "HTAtom.h"
  43. #include "HTWriter.h"
  44. #include "HTFWriter.h"
  45. #include "HTInit.h"
  46. #include "HTBTree.h"
  47.  
  48. typedef struct _HTSuffix {
  49.     char *        suffix;
  50.     HTAtom *    rep;
  51.     HTAtom *    encoding;
  52.     float        quality;
  53. } HTSuffix;
  54.  
  55.  
  56. #ifdef USE_DIRENT        /* Set this for Sys V systems */
  57. #define STRUCT_DIRENT struct dirent
  58. #else
  59. #define STRUCT_DIRENT struct direct
  60. #endif
  61.  
  62. #include "HTML.h"        /* For directory object building */
  63.  
  64. #define PUTC(c) (*target->isa->put_character)(target, c)
  65. #define PUTS(s) (*target->isa->put_string)(target, s)
  66. #define START(e) (*target->isa->start_element)(target, e, 0, 0)
  67. #define END(e) (*target->isa->end_element)(target, e)
  68. #define FREE_TARGET (*target->isa->free)(target)
  69. struct _HTStructured {
  70.     CONST HTStructuredClass *    isa;
  71.     /* ... */
  72. };
  73.  
  74.  
  75. /*                   Controlling globals
  76. **
  77. */
  78.  
  79. PUBLIC int HTDirAccess = HT_DIR_OK;
  80. PUBLIC int HTDirReadme = HT_DIR_README_TOP;
  81.  
  82. PRIVATE char *HTMountRoot = "/Net/";        /* Where to find mounts */
  83. #ifdef VMS
  84. PRIVATE char *HTCacheRoot = "/WWW$SCRATCH";   /* Where to cache things */
  85. #else
  86. PRIVATE char *HTCacheRoot = "/tmp/W3_Cache_";   /* Where to cache things */
  87. #endif
  88.  
  89. /* PRIVATE char *HTSaveRoot  = "$(HOME)/WWW/";*/    /* Where to save things */
  90.  
  91.  
  92. /*    Suffix registration
  93. */
  94.  
  95. PRIVATE HTList * HTSuffixes = 0;
  96. PRIVATE HTSuffix no_suffix = { "*", NULL, NULL, 1.0 };
  97. PRIVATE HTSuffix unknown_suffix = { "*.*", NULL, NULL, 1.0};
  98.  
  99.  
  100. /*    Define the representation associated with a file suffix
  101. **    -------------------------------------------------------
  102. **
  103. **    Calling this with suffix set to "*" will set the default
  104. **    representation.
  105. **    Calling this with suffix set to "*.*" will set the default
  106. **    representation for unknown suffix files which contain a ".".
  107. **
  108. **    If filename suffix is already defined its previous
  109. **    definition is overridden.
  110. */
  111. PUBLIC void HTSetSuffix ARGS4(
  112.     CONST char *,    suffix,
  113.     CONST char *,    representation,
  114.     CONST char *,    encoding,
  115.     float,        value)
  116. {
  117.     
  118.     HTSuffix * suff;
  119.  
  120.     if (strcmp(suffix, "*")==0) suff = &no_suffix;
  121.     else if (strcmp(suffix, "*.*")==0) suff = &unknown_suffix;
  122.     else {
  123.     HTList *cur = HTSuffixes;
  124.  
  125.     while (NULL != (suff = (HTSuffix*)HTList_nextObject(cur))) {
  126.         if (suff->suffix && 0==strcmp(suff->suffix, suffix))
  127.         break;
  128.     }
  129.     if (!suff) { /* Not found -- create a new node */
  130.         suff = (HTSuffix*) calloc(1, sizeof(HTSuffix));
  131.         if (suff == NULL) outofmem(__FILE__, "HTSetSuffix");
  132.     
  133.         if (!HTSuffixes) HTSuffixes = HTList_new();
  134.         HTList_addObject(HTSuffixes, suff);
  135.     
  136.         StrAllocCopy(suff->suffix, suffix);
  137.     }
  138.     }
  139.  
  140.     suff->rep = HTAtom_for(representation);
  141.  
  142.     {
  143.         char * enc = NULL;
  144.     char * p;
  145.     StrAllocCopy(enc, encoding);
  146.     for (p=enc; *p; p++) *p = TOLOWER(*p);
  147.     suff->encoding = HTAtom_for(encoding);
  148.     }
  149.     
  150.     suff->quality = value;
  151. }
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159. /*    Send README file
  160. **
  161. **  If a README file exists, then it is inserted into the document here.
  162. */
  163.  
  164. #ifdef GOT_READ_DIR
  165. PRIVATE void do_readme ARGS2(HTStructured *, target, CONST char *, localname)
  166. { 
  167.     FILE * fp;
  168.     char * readme_file_name = 
  169.     malloc(strlen(localname)+ 1 + strlen(HT_DIR_README_FILE) + 1);
  170.     strcpy(readme_file_name, localname);
  171.     strcat(readme_file_name, "/");
  172.     strcat(readme_file_name, HT_DIR_README_FILE);
  173.     
  174.     fp = fopen(readme_file_name,  "r");
  175.     
  176.     if (fp) {
  177.     HTStructuredClass targetClass;
  178.     
  179.     targetClass =  *target->isa;    /* (Can't init agregate in K&R) */
  180. #ifdef MSDOSMEM
  181.     {
  182.         extern void *vp_msdosmem;
  183.         extern void **vpp_msdosmem;
  184.         vp_msdosmem = NULL;
  185.         vpp_msdosmem = NULL;
  186.     }
  187. #endif /* MSDOSMEM */
  188.     START(HTML_PRE);
  189.     for(;;){
  190.         char c = fgetc(fp);
  191.         if (c == (char)EOF) break;
  192.         switch (c) {
  193.             case '&':
  194.         case '<':
  195.         case '>':
  196.             PUTC('&');
  197.             PUTC('#');
  198.             PUTC((char)(c / 10));
  199.             PUTC((char) (c % 10));
  200.             PUTC(';');
  201.             break;
  202. /*            case '\n':
  203.             PUTC('\r');    
  204. Bug removed thanks to joe@athena.mit.edu */            
  205.         default:
  206.             PUTC(c);
  207.         }
  208.     }
  209.     END(HTML_PRE);
  210.     fclose(fp);
  211.     } 
  212. }
  213. #endif
  214.  
  215.  
  216. /*    Make the cache file name for a W3 document
  217. **    ------------------------------------------
  218. **    Make up a suitable name for saving the node in
  219. **
  220. **    E.g.    /tmp/WWW_Cache_news/1234@cernvax.cern.ch
  221. **        /tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
  222. **
  223. ** On exit,
  224. **    returns    a malloc'ed string which must be freed by the caller.
  225. */
  226. PUBLIC char * HTCacheFileName ARGS1(CONST char *,name)
  227. {
  228.     char * access = HTParse(name, "", PARSE_ACCESS);
  229.     char * host = HTParse(name, "", PARSE_HOST);
  230.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  231.     
  232.     char * result;
  233.     result = (char *)malloc(
  234.         strlen(HTCacheRoot)+strlen(access)
  235.         +strlen(host)+strlen(path)+6+1);
  236.     if (result == NULL) outofmem(__FILE__, "HTCacheFileName");
  237.     sprintf(result, "%s/WWW/%s/%s%s", HTCacheRoot, access, host, path);
  238.     free(path);
  239.     free(access);
  240.     free(host);
  241.     return result;
  242. }
  243.  
  244.  
  245. /*    Open a file for write, creating the path
  246. **    ----------------------------------------
  247. */
  248. #ifdef NOT_IMPLEMENTED
  249. PRIVATE int HTCreatePath ARGS1(CONST char *,path)
  250. {
  251.     return -1;
  252. }
  253. #endif
  254.  
  255. /*    Convert filenames between local and WWW formats
  256. **    -----------------------------------------------
  257. **    Make up a suitable name for saving the node in
  258. **
  259. **    E.g.    $(HOME)/WWW/news/1234@cernvax.cern.ch
  260. **        $(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
  261. **
  262. ** On exit,
  263. **    returns    a malloc'ed string which must be freed by the caller.
  264. */
  265. PUBLIC char * HTLocalName ARGS1(CONST char *,name)
  266. {
  267.     char * access = HTParse(name, "", PARSE_ACCESS);
  268.     char * host = HTParse(name, "", PARSE_HOST);
  269.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  270.     
  271.     HTUnEscape(path);    /* Interpret % signs */
  272.     
  273.     if (0==strcmp(access, "file")) { /* local file */
  274.         free(access);    
  275.     if ((0==strcasecomp(host, HTHostName())) ||
  276.         (0==strcasecomp(host, "localhost")) || !*host) {
  277.         free(host);
  278.         if (TRACE) fprintf(stderr, "Node `%s' means path `%s'\n", name, path);
  279. #ifdef MSDOS
  280.         {
  281.             /*
  282.              *    Convert the path to a dos file name.
  283.              */
  284.             extern void urltodos(char *);
  285.  
  286.             urltodos(path);
  287.         }
  288. #endif /* MSDOS */
  289.         return(path);
  290.     } else {
  291.         char * result = (char *)malloc(
  292.                     strlen("/Net/")+strlen(host)+strlen(path)+1);
  293.           if (result == NULL) outofmem(__FILE__, "HTLocalName");
  294.         sprintf(result, "%s%s%s", "/Net/", host, path);
  295.         free(host);
  296.         free(path);
  297.         if (TRACE) fprintf(stderr, "Node `%s' means file `%s'\n", name, result);
  298.         return result;
  299.     }
  300.     } else {  /* other access */
  301.     char * result;
  302.         CONST char * home =  (CONST char*)getenv("HOME");
  303. #ifdef VMS
  304.     if (!home) 
  305.         home = HTCacheRoot; 
  306.     else
  307.            home = HTVMS_wwwName(home);
  308. #else /* not VMS */
  309.     if (!home) home = "/tmp"; 
  310. #endif /* not VMS */
  311.     result = (char *)malloc(
  312.         strlen(home)+strlen(access)+strlen(host)+strlen(path)+6+1);
  313.       if (result == NULL) outofmem(__FILE__, "HTLocalName");
  314.     sprintf(result, "%s/WWW/%s/%s%s", home, access, host, path);
  315.     free(path);
  316.     free(access);
  317.     free(host);
  318.     return result;
  319.     }
  320. }
  321.  
  322.  
  323. /*    Make a WWW name from a full local path name
  324. **
  325. ** Bugs:
  326. **    At present, only the names of two network root nodes are hand-coded
  327. **    in and valid for the NeXT only. This should be configurable in
  328. **    the general case.
  329. */
  330.  
  331. PUBLIC char * WWW_nameOfFile ARGS1 (CONST char *,name)
  332. {
  333.     char * result;
  334. #ifdef NeXT
  335.     if (0==strncmp("/private/Net/", name, 13)) {
  336.     result = (char *)malloc(7+strlen(name+13)+1);
  337.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  338.     sprintf(result, "file://%s", name+13);
  339.     } else
  340. #endif
  341.     if (0==strncmp(HTMountRoot, name, 5)) {
  342.     result = (char *)malloc(7+strlen(name+5)+1);
  343.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  344.     sprintf(result, "file://%s", name+5);
  345.     } else {
  346.         result = (char *)malloc(7+strlen(HTHostName())+strlen(name)+1);
  347.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  348.     sprintf(result, "file://%s%s", HTHostName(), name);
  349.     }
  350.     if (TRACE) fprintf(stderr, "File `%s'\n\tmeans node `%s'\n", name, result);
  351.     return result;
  352. }
  353.  
  354.  
  355. /*    Determine a suitable suffix, given the representation
  356. **    -----------------------------------------------------
  357. **
  358. ** On entry,
  359. **    rep    is the atomized MIME style representation
  360. **
  361. ** On exit,
  362. **    returns    a pointer to a suitable suffix string if one has been
  363. **        found, else "".
  364. */
  365. PUBLIC CONST char * HTFileSuffix ARGS1(HTAtom*, rep)
  366. {
  367.     HTSuffix * suff;
  368.     int n;
  369.     int i;
  370.  
  371. #ifndef NO_INIT    
  372.     if (!HTSuffixes) HTFileInit();
  373. #endif
  374.     n = HTList_count(HTSuffixes);
  375.     for(i=0; i<n; i++) {
  376.     suff = HTList_objectAt(HTSuffixes, i);
  377.     if (suff->rep == rep) {
  378.         return suff->suffix;        /* OK -- found */
  379.     }
  380.     }
  381.     return "";        /* Dunno */
  382. }
  383.  
  384.  
  385. /*    Determine file format from file name
  386. **    ------------------------------------
  387. **
  388. **    This version will return the representation and also set
  389. **    a variable for the encoding.
  390. **
  391. **    It will handle for example  x.txt, x.txt,Z, x.Z
  392. */
  393.  
  394. PUBLIC HTFormat HTFileFormat ARGS2 (
  395.             CONST char *,    filename,
  396.             HTAtom **,    pencoding)
  397.  
  398. {
  399.     HTSuffix * suff;
  400.     int n;
  401.     int i;
  402.     int lf = strlen(filename);
  403.  
  404. #ifndef NO_INIT    
  405.     if (!HTSuffixes) HTFileInit();
  406. #endif
  407.     *pencoding = NULL;
  408.     n = HTList_count(HTSuffixes);
  409.     for(i=0; i<n; i++) {
  410.         int ls;
  411.     suff = HTList_objectAt(HTSuffixes, i);
  412.     ls = strlen(suff->suffix);
  413.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  414.         int j;
  415.         *pencoding = suff->encoding;
  416.         if (suff->rep) return suff->rep;        /* OK -- found */
  417.         
  418.         for(j=0; j<n; j++) {  /* Got encoding, need representation */
  419.         int ls2;
  420.         suff = HTList_objectAt(HTSuffixes, j);
  421.         ls2 = strlen(suff->suffix);
  422.         if ((ls <= lf) && 0==strncmp(
  423.             suff->suffix, filename + lf - ls -ls2, ls2)) {
  424.             if (suff->rep) return suff->rep;
  425.         }
  426.         }
  427.         
  428.     }
  429.     }
  430.     
  431.     /* defaults tree */
  432.     
  433.     suff = strchr(filename, '.') ?     /* Unknown suffix */
  434.      ( unknown_suffix.rep ? &unknown_suffix : &no_suffix)
  435.      : &no_suffix;
  436.      
  437.     /* set default encoding unless found with suffix already */
  438.     if (!*pencoding) *pencoding = suff->encoding ? suff->encoding
  439.                     : HTAtom_for("binary");
  440.     return suff->rep ? suff->rep : WWW_BINARY;
  441. }
  442.  
  443.  
  444. /*    Determine value from file name
  445. **    ------------------------------
  446. **
  447. */
  448.  
  449. PUBLIC float HTFileValue ARGS1 (CONST char *,filename)
  450.  
  451. {
  452.     HTSuffix * suff;
  453.     int n;
  454.     int i;
  455.     int lf = strlen(filename);
  456.  
  457. #ifndef NO_INIT    
  458.     if (!HTSuffixes) HTFileInit();
  459. #endif
  460.     n = HTList_count(HTSuffixes);
  461.     for(i=0; i<n; i++) {
  462.         int ls;
  463.     suff = HTList_objectAt(HTSuffixes, i);
  464.     ls = strlen(suff->suffix);
  465.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  466.         if (TRACE) fprintf(stderr, "File: Value of %s is %.3f\n",
  467.                    filename, suff->quality);
  468.         return suff->quality;        /* OK -- found */
  469.     }
  470.     }
  471.     return 0.3;        /* Dunno! */
  472. }
  473.  
  474.  
  475. /*    Determine write access to a file
  476. **    --------------------------------
  477. **
  478. ** On exit,
  479. **    return value    YES if file can be accessed and can be written to.
  480. **
  481. ** Bugs:
  482. **    1.    No code for non-unix systems.
  483. **    2.    Isn't there a quicker way?
  484. */
  485.  
  486. #ifdef VMS
  487. #define NO_GROUPS
  488. #endif
  489. #ifdef NO_UNIX_IO
  490. #define NO_GROUPS
  491. #endif
  492. #ifdef PCNFS
  493. #define NO_GROUPS
  494. #endif
  495. #ifdef MSDOS
  496. #define NO_GROUPS
  497. #endif
  498.  
  499. PUBLIC BOOL HTEditable ARGS1 (CONST char *,filename)
  500. {
  501. #ifdef NO_GROUPS
  502.     return NO;        /* Safe answer till we find the correct algorithm */
  503. #else
  504.     int     groups[NGROUPS];
  505.     uid_t    myUid;
  506.     int        ngroups;            /* The number of groups  */
  507.     struct stat    fileStatus;
  508.     int        i;
  509.  
  510.     if (stat(filename, &fileStatus))        /* Get details of filename */
  511.     return NO;                /* Can't even access file! */
  512.  
  513.     ngroups = getgroups(NGROUPS, groups);    /* Groups to which I belong  */
  514.     myUid = geteuid();                /* Get my user identifier */
  515.  
  516.     if (TRACE) {
  517.         int i;
  518.     fprintf(stderr, 
  519.         "File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  520.             (unsigned int) fileStatus.st_mode, fileStatus.st_uid,
  521.         fileStatus.st_gid,
  522.         myUid, ngroups);
  523.     for (i=0; i<ngroups; i++) fprintf(stderr, " %d", groups[i]);
  524.     fprintf(stderr, ")\n");
  525.     }
  526.     
  527.     if (fileStatus.st_mode & 0002)        /* I can write anyway? */
  528.         return YES;
  529.     
  530.     if ((fileStatus.st_mode & 0200)        /* I can write my own file? */
  531.      && (fileStatus.st_uid == myUid))
  532.         return YES;
  533.  
  534.     if (fileStatus.st_mode & 0020)        /* Group I am in can write? */
  535.     {
  536.        for (i=0; i<ngroups; i++) {
  537.             if (groups[i] == fileStatus.st_gid)
  538.         return YES;
  539.     }
  540.     }
  541.     if (TRACE) fprintf(stderr, "\tFile is not editable.\n");
  542.     return NO;                    /* If no excuse, can't do */
  543. #endif
  544. }
  545.  
  546.  
  547. /*    Make a save stream
  548. **    ------------------
  549. **
  550. **    The stream must be used for writing back the file.
  551. **    @@@ no backup done
  552. */
  553. PUBLIC HTStream * HTFileSaveStream ARGS1(HTParentAnchor *, anchor)
  554. {
  555.  
  556.     CONST char * addr = HTAnchor_address((HTAnchor*)anchor);
  557.     char *  localname = HTLocalName(addr);
  558.  
  559.     FILE* fp = fopen(localname, "w");
  560.     if (!fp) return NULL;
  561.     
  562.     return HTFWriter_new(fp);
  563.     
  564. }
  565.  
  566. /*      Output one directory entry
  567. **
  568. */
  569. PUBLIC void HTDirEntry ARGS3(HTStructured *, target,
  570.          CONST char * , tail,
  571.          CONST char *,  entry)
  572. {
  573.     char * relative;
  574.     char * escaped = HTEscape(entry, URL_XPALPHAS);
  575.  
  576.     /* If empty tail, gives absolute ref below */
  577.     relative = (char*) malloc(
  578.                   strlen(tail) + strlen(escaped)+2);
  579.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  580.     sprintf(relative, "%s/%s", tail, escaped);
  581.     HTStartAnchor(target, NULL, relative);
  582.     free(escaped);
  583.     free(relative);
  584.     PUTS(entry);
  585.     END(HTML_A);
  586. }
  587.  
  588. /*      Output parent directory entry
  589. **
  590. **    This gives the TITLE and H1 header, and also a link
  591. **    to the parent directory if appropriate.
  592. */
  593. PUBLIC void HTDirTitles ARGS2(HTStructured *, target,
  594.          HTAnchor * , anchor)
  595.  
  596. {
  597.     char * logical = HTAnchor_address(anchor);
  598.     char * path = HTParse(logical, "", PARSE_PATH + PARSE_PUNCTUATION);
  599.     char * current;
  600.  
  601.     current = strrchr(path, '/');    /* last part or "" */
  602.     free(logical);
  603.  
  604.     {
  605.       char * printable = NULL;
  606.       StrAllocCopy(printable, (current + 1));
  607.       HTUnEscape(printable);
  608. #ifdef MSDOSMEM
  609.     {
  610.         extern void *vp_msdosmem;
  611.         extern void **vpp_msdosmem;
  612.         vp_msdosmem = NULL;
  613.         vpp_msdosmem = NULL;
  614.     }
  615. #endif /* MSDOSMEM */
  616.       START(HTML_TITLE);
  617.       PUTS(*printable ? printable : "Welcome ");
  618.       PUTS(" directory");
  619.       END(HTML_TITLE);    
  620.     
  621. #ifdef MSDOSMEM
  622.     {
  623.         extern void *vp_msdosmem;
  624.         extern void **vpp_msdosmem;
  625.         vp_msdosmem = NULL;
  626.         vpp_msdosmem = NULL;
  627.     }
  628. #endif /* MSDOSMEM */
  629.       START(HTML_H1);
  630.       PUTS(*printable ? printable : "Welcome");
  631.       END(HTML_H1);
  632.       free(printable);
  633.     }
  634.  
  635.     /*  Make link back to parent directory
  636.      */
  637.  
  638.     if (current && current[1]) {   /* was a slash AND something else too */
  639.         char * parent;
  640.     char * relative;
  641.     *current++ = 0;
  642.       parent = strrchr(path, '/');  /* penultimate slash */
  643.  
  644.     relative = (char*) malloc(strlen(current) + 4);
  645.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  646.     sprintf(relative, "%s/..", current);
  647.     HTStartAnchor(target, "", relative);
  648.     free(relative);
  649.  
  650.     PUTS("Up to ");
  651.     if (parent) {
  652.       char * printable = NULL;
  653.       StrAllocCopy(printable, parent + 1);
  654.       HTUnEscape(printable);
  655.       PUTS(printable);
  656.       free(printable);
  657.     } else {
  658.       PUTS("/");
  659.     }
  660.  
  661.     END(HTML_A);
  662.  
  663.     }
  664.     free(path);
  665. }
  666.         
  667.  
  668.  
  669. /*    Load a document
  670. **    ---------------
  671. **
  672. ** On entry,
  673. **    addr        must point to the fully qualified hypertext reference.
  674. **            This is the physsical address of the file
  675. **
  676. ** On exit,
  677. **    returns        <0        Error has occured.
  678. **            HTLOADED    OK 
  679. **
  680. */
  681. PUBLIC int HTLoadFile ARGS4 (
  682.     CONST char *,        addr,
  683.     HTParentAnchor *,    anchor,
  684.     HTFormat,        format_out,
  685.     HTStream *,        sink
  686. )
  687. {
  688.     char * filename;
  689.     HTFormat format;
  690.     char * nodename = 0;
  691.     char * newname=0;    /* Simplified name of file */
  692.     HTAtom * encoding;    /* @@ not used yet */
  693.     
  694. /*    Reduce the filename to a basic form (hopefully unique!)
  695. */
  696.     StrAllocCopy(newname, addr);
  697.     filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
  698.     nodename=HTParse(newname, "", PARSE_HOST);
  699.     free(newname);
  700.     
  701.     format = HTFileFormat(filename, &encoding);
  702.  
  703.  
  704. #ifdef VMS
  705. /* Assume that the file is in Unix-style syntax if it contains a '/'
  706.    after the leading one @@ */
  707.     {
  708.         FILE * fp;
  709.     char * vmsname = strchr(filename + 1, '/') ?
  710.       HTVMS_name(nodename, filename) : filename + 1;
  711.     fp = fopen(vmsname, "r", "shr=put", "shr=upd");
  712.     
  713. /*    If the file wasn't VMS syntax, then perhaps it is ultrix
  714. */
  715.     if (!fp) {
  716.         char ultrixname[INFINITY];
  717.         if (TRACE) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
  718.         sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
  719.           fp = fopen(ultrixname, "r", "shr=put", "shr=upd");
  720.         if (!fp) {
  721.         if (TRACE) fprintf(stderr, 
  722.                    "HTFile: Can't open as %s\n", ultrixname);
  723.         }
  724.     }
  725.         if (fp)
  726.         {
  727.         if (HTEditable(vmsname)) {
  728.         HTAtom * put = HTAtom_for("PUT");
  729.         HTList * methods = HTAnchor_methods(anchor);
  730.         if (HTList_indexOf(methods, put) == (-1)) {
  731.                HTList_addObject(methods, put);
  732.             }
  733.         }
  734.         HTParseFile(format, format_out, anchor, fp, sink);
  735.         fclose(fp);
  736.             return HT_LOADED;
  737.         }  /* If successfull open */
  738.     }
  739. #else
  740.  
  741.     free(filename);
  742.     
  743. /*    For unix, we try to translate the name into the name of a transparently
  744. **    mounted file.
  745. **
  746. **    Not allowed in secure (HTClienntHost) situations TBL 921019
  747. */
  748. #ifndef NO_UNIX_IO
  749.     /*  Need protection here for telnet server but not httpd server */
  750.      
  751.     if (!HTSecure) {        /* try local file system */
  752.     char * localname = HTLocalName(addr);
  753.     struct stat dir_info;
  754.     
  755. #ifdef GOT_READ_DIR
  756.  
  757. /*              Multiformat handling
  758. **
  759. **    If needed, scan directory to find a good file.
  760. **  Bug:  we don't stat the file to find the length
  761. */
  762.     if ( (strlen(localname) > strlen(MULTI_SUFFIX))
  763.        && (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
  764.               MULTI_SUFFIX))) {
  765.         DIR *dp;
  766.  
  767.         STRUCT_DIRENT * dirbuf;
  768.         float best = NO_VALUE_FOUND;    /* So far best is bad */
  769.         HTFormat best_rep = NULL;    /* Set when rep found */
  770.         STRUCT_DIRENT best_dirbuf;    /* Best dir entry so far */
  771.  
  772.         char * base = strrchr(localname, '/');
  773.         int baselen;
  774.  
  775.         if (!base || base == localname) goto forget_multi;
  776.         *base++ = 0;        /* Just got directory name */
  777.         baselen = strlen(base)- strlen(MULTI_SUFFIX);
  778.         base[baselen] = 0;    /* Chop off suffix */
  779.  
  780.         dp = opendir(localname);
  781.         if (!dp) {
  782. forget_multi:
  783.         free(localname);
  784.         return HTLoadError(sink, 500,
  785.             "Multiformat: directory scan failed.");
  786.         }
  787.         
  788.         while ((dirbuf = readdir(dp))!=0) {
  789.             /* while there are directory entries to be read */
  790.         if (dirbuf->d_ino == 0) continue;
  791.                 /* if the entry is not being used, skip it */
  792.         
  793.         if (dirbuf->d_namlen > baselen &&      /* Match? */
  794.             !strncmp(dirbuf->d_name, base, baselen)) {    
  795.             HTFormat rep = HTFileFormat(dirbuf->d_name, &encoding);
  796.             float value = HTStackValue(rep, format_out,
  797.                             HTFileValue(dirbuf->d_name),
  798.                         0.0  /* @@@@@@ */);
  799.             if (value != NO_VALUE_FOUND) {
  800.             if (TRACE) fprintf(stderr,
  801.                 "HTFile: value of presenting %s is %f\n",
  802.                 HTAtom_name(rep), value);
  803.             if  (value > best) {
  804.                 best_rep = rep;
  805.                 best = value;
  806.                 best_dirbuf = *dirbuf;
  807.                }
  808.             }    /* if best so far */             
  809.          } /* if match */  
  810.             
  811.         } /* end while directory entries left to read */
  812.         closedir(dp);
  813.         
  814.         if (best_rep) {
  815.         format = best_rep;
  816.         base[-1] = '/';        /* Restore directory name */
  817.         base[0] = 0;
  818.         StrAllocCat(localname, best_dirbuf.d_name);
  819.         goto open_file;
  820.         
  821.         } else {             /* If not found suitable file */
  822.         free(localname);
  823.         return HTLoadError(sink, 403,    /* List formats? */
  824.            "Could not find suitable representation for transmission.");
  825.         }
  826.         /*NOTREACHED*/
  827.     } /* if multi suffix */
  828. /*
  829. **    Check to see if the 'localname' is in fact a directory.  If it is
  830. **    create a new hypertext object containing a list of files and 
  831. **    subdirectories contained in the directory.  All of these are links
  832. **      to the directories or files listed.
  833. **      NB This assumes the existance of a type 'STRUCT_DIRENT', which will
  834. **      hold the directory entry, and a type 'DIR' which is used to point to
  835. **      the current directory being read.
  836. */
  837.     
  838.     
  839.     if (stat(localname,&dir_info) == -1) {     /* get file information */
  840.                                    /* if can't read file information */
  841.         if (TRACE) fprintf(stderr, "HTFile: can't stat %s\n", localname);
  842.  
  843.     }  else {        /* Stat was OK */
  844.         
  845.  
  846.         if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
  847.         /* if localname is a directory */    
  848.  
  849.         HTStructured* target;        /* HTML object */
  850.         HTStructuredClass targetClass;
  851.  
  852.         DIR *dp;
  853.         STRUCT_DIRENT * dirbuf;
  854.         
  855.         char * logical;
  856.         char * tail;
  857.         
  858.         BOOL present[HTML_A_ATTRIBUTES];
  859.         
  860.         char * tmpfilename = NULL;
  861.         struct stat file_info;
  862.         
  863.         if (TRACE)
  864.             fprintf(stderr,"%s is a directory\n",localname);
  865.             
  866. /*    Check directory access.
  867. **    Selective access means only those directories containing a
  868. **    marker file can be browsed
  869. */
  870.         if (HTDirAccess == HT_DIR_FORBID) {
  871.             free(localname);
  872.             return HTLoadError(sink, 403,
  873.             "Directory browsing is not allowed.");
  874.         }
  875.  
  876.  
  877.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  878.             char * enable_file_name = 
  879.             malloc(strlen(localname)+ 1 +
  880.              strlen(HT_DIR_ENABLE_FILE) + 1);
  881.             strcpy(enable_file_name, localname);
  882.             strcat(enable_file_name, "/");
  883.             strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  884.             if (stat(enable_file_name, &file_info) != 0) {
  885.             free(localname);
  886.             return HTLoadError(sink, 403,
  887.             "Selective access is not enabled for this directory");
  888.             }
  889.         }
  890.  
  891.  
  892.         dp = opendir(localname);
  893.         if (!dp) {
  894.             free(localname);
  895.             return HTLoadError(sink, 403, "This directory is not readable.");
  896.         }
  897.  
  898.  
  899.  /*    Directory access is allowed and possible
  900.  */
  901.         logical = HTAnchor_address((HTAnchor*)anchor);
  902.         tail = strrchr(logical, '/') +1;    /* last part or "" */
  903.         
  904.         target = HTML_new(anchor, format_out, sink);
  905.         targetClass = *target->isa;    /* Copy routine entry points */
  906.             
  907.           { int i;
  908.             for(i=0; i<HTML_A_ATTRIBUTES; i++)
  909.                 present[i] = (i==HTML_A_HREF);
  910.         }
  911.         
  912.                 HTDirTitles(target, (HTAnchor *)anchor);
  913.  
  914.         if (HTDirReadme == HT_DIR_README_TOP)
  915.             do_readme(target, localname);
  916.         {
  917.             HTBTree * bt = HTBTree_new((HTComparer)strcasecomp);
  918.  
  919.             while ((dirbuf = readdir(dp))!=0)
  920.             {
  921.                 HTBTElement * dirname = NULL;
  922.  
  923.                 /* while there are directory entries to be read */
  924.                 if (dirbuf->d_ino == 0)
  925.                   /* if the entry is not being used, skip it */
  926.                 continue;
  927.             
  928.  
  929.                 /* if the current entry is parent directory */
  930.             if ((*(dirbuf->d_name)=='.') ||
  931.                 (*(dirbuf->d_name)==','))
  932.                 continue;    /* skip those files whose name begins
  933.                         with '.' or ',' */
  934.  
  935.             dirname = (HTBTElement *)malloc(
  936.                     strlen(dirbuf->d_name) + 2);
  937.             if (dirname == NULL) outofmem(__FILE__,"DirRead");
  938.             StrAllocCopy(tmpfilename,localname);
  939.             if (strcmp(localname,"/"))
  940.  
  941.                     /* if filename is not root directory */
  942.                 StrAllocCat(tmpfilename,"/"); 
  943.  
  944.  
  945.             StrAllocCat(tmpfilename,dirbuf->d_name);
  946.             stat(tmpfilename, &file_info);
  947.             if (((file_info.st_mode) & S_IFMT) == S_IFDIR)
  948.                 sprintf((char *)dirname,"D%s",dirbuf->d_name);
  949.             else sprintf((char *)dirname,"F%s",dirbuf->d_name);
  950.                 /* D & F to have first directories, then files */
  951.             HTBTree_add(bt,dirname); /* Sort dirname in the tree bt */
  952.             }
  953.  
  954.             /*    Run through tree printing out in order
  955.              */
  956.             {
  957.                 HTBTElement * next_element = HTBTree_next(bt,NULL);
  958.                 /* pick up the first element of the list */
  959.             char state;
  960.                 /* I for initial (.. file),
  961.                    D for directory file,
  962.                    F for file */
  963.             
  964.             state = 'I';
  965.  
  966.             while (next_element != NULL)
  967.                 {
  968.                 StrAllocCopy(tmpfilename,localname);
  969.                 if (strcmp(localname,"/")) 
  970.  
  971.                     /* if filename is not root directory */
  972.                     StrAllocCat(tmpfilename,"/"); 
  973.  
  974.                 StrAllocCat(tmpfilename,
  975.                     (char *)HTBTree_object(next_element)+1);
  976.                 /* append the current entry's filename to the path */
  977.                 HTSimplify(tmpfilename);
  978.                 /* Output the directory entry */
  979.                 if (strcmp((char *)
  980.                          (HTBTree_object(next_element)),"D.."))
  981.                 {                
  982.                 if (state != *(char *)(HTBTree_object(next_element)))
  983.                 {
  984.                     if (state == 'D')
  985.                         END(HTML_DIR);
  986.                     state = *(char *)
  987.                         (HTBTree_object(next_element))=='D'?'D':'F';
  988. #ifdef MSDOSMEM
  989.     {
  990.         extern void *vp_msdosmem;
  991.         extern void **vpp_msdosmem;
  992.         vp_msdosmem = NULL;
  993.         vpp_msdosmem = NULL;
  994.     }
  995. #endif /* MSDOSMEM */
  996.                     START(HTML_H2);
  997.                     PUTS(state == 'D'?"Subdirectories:":"Files");
  998.                     END(HTML_H2);
  999. #ifdef MSDOSMEM
  1000.     {
  1001.         extern void *vp_msdosmem;
  1002.         extern void **vpp_msdosmem;
  1003.         vp_msdosmem = NULL;
  1004.         vpp_msdosmem = NULL;
  1005.     }
  1006. #endif /* MSDOSMEM */
  1007.                     START(HTML_DIR);
  1008.                 }
  1009. #ifdef MSDOSMEM
  1010.     {
  1011.         extern void *vp_msdosmem;
  1012.         extern void **vpp_msdosmem;
  1013.         vp_msdosmem = NULL;
  1014.         vpp_msdosmem = NULL;
  1015.     }
  1016. #endif /* MSDOSMEM */
  1017.                 START(HTML_LI);
  1018.                 }
  1019.                 HTDirEntry(target, tail,
  1020.                        (char*)HTBTree_object(next_element) +1);
  1021.  
  1022.                 next_element = HTBTree_next(bt,next_element);
  1023.                     /* pick up the next element of the list; 
  1024.                  if none, return NULL*/
  1025.             }
  1026.             if (state == 'I')
  1027.             {
  1028. #ifdef MSDOSMEM
  1029.     {
  1030.         extern void *vp_msdosmem;
  1031.         extern void **vpp_msdosmem;
  1032.         vp_msdosmem = NULL;
  1033.         vpp_msdosmem = NULL;
  1034.     }
  1035. #endif /* MSDOSMEM */
  1036.                 START(HTML_P);
  1037.                 PUTS("Empty Directory");
  1038.             }
  1039.             else
  1040.                 END(HTML_DIR);
  1041.             }
  1042.  
  1043.                 /* end while directory entries left to read */
  1044.             closedir(dp);
  1045.             free(logical);
  1046.             free(tmpfilename);
  1047.             HTBTreeAndObject_free(bt);
  1048.  
  1049.             if (HTDirReadme == HT_DIR_README_BOTTOM)
  1050.               do_readme(target, localname);
  1051.             FREE_TARGET;
  1052.             free(localname);
  1053.             return HT_LOADED;    /* document loaded */
  1054.         }
  1055.  
  1056.         } /* end if localname is directory */
  1057.     
  1058.     } /* end if file stat worked */
  1059.     
  1060. /* End of directory reading section
  1061. */
  1062. #endif
  1063. open_file:
  1064.     {
  1065.         FILE * fp = fopen(localname,"r");
  1066.  
  1067.         if(TRACE) fprintf (stderr, "HTFile: Opening `%s' gives %p\n",
  1068.                 localname, (void*)fp);
  1069.         if (fp) {        /* Good! */
  1070.         if (HTEditable(localname)) {
  1071.             HTAtom * put = HTAtom_for("PUT");
  1072.             HTList * methods = HTAnchor_methods(anchor);
  1073.             if (HTList_indexOf(methods, put) == (-1)) {
  1074.             HTList_addObject(methods, put);
  1075.             }
  1076.         }
  1077.         free(localname);
  1078.         HTParseFile(format, format_out, anchor, fp, sink);
  1079.         fclose(fp);
  1080.         return HT_LOADED;
  1081.         }  /* If succesfull open */
  1082.     }    /* scope of fp */
  1083.     }  /* local unix file system */    
  1084. #endif
  1085. #endif
  1086.  
  1087. #ifndef DECNET
  1088. /*    Now, as transparently mounted access has failed, we try FTP.
  1089. */
  1090.     {
  1091.     if (strcmp(nodename, HTHostName())!=0)
  1092.         return HTFTPLoad(addr, anchor, format_out, sink);
  1093.     }
  1094. #endif
  1095.  
  1096. /*    All attempts have failed.
  1097. */
  1098.     {
  1099.         if (TRACE)
  1100.         printf("Can't open `%s', errno=%d\n", addr, errno);
  1101.  
  1102.     return HTLoadError(sink, 403, "Can't access requested file.");
  1103.     }
  1104.     
  1105.  
  1106. }
  1107.  
  1108. /*        Protocol descriptors
  1109. */
  1110. GLOBALDEF PUBLIC HTProtocol HTFTP  = { "ftp", HTLoadFile, 0 };
  1111. GLOBALDEF PUBLIC HTProtocol HTFile = { "file", HTLoadFile, HTFileSaveStream };